Etude sur le jeu de données "Wine Quality"
Source : UCI Machine Learning RepositoryP. Cortez, A. Cerdeira, F. Almeida, T. Matos and J. Reis. Modeling wine preferences by data mining from physicochemical properties. In Decision Support Systems, Elsevier, 47(4):547-553, 2009.
0- Bibliothèques python utilisé :¶
In [1]:
import pandas as pd
import numpy as np
def warn(*args, **kwargs):
pass
import warnings
warnings.warn = warn
import matplotlib.pyplot as plt
plt.style.use('ggplot')
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.calibration import CalibratedClassifierCV
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn import metrics
from sklearn.metrics import accuracy_score
from sklearn.metrics import plot_confusion_matrix
from joblib import dump, load
1- Lecture et visualisation des données :¶
a- lecture des deux jeux de données :¶
In [2]:
redWine = pd.read_csv("./data/winequality-red.csv",sep=";")
whiteWine = pd.read_csv("./data/winequality-white.csv",sep=";")
b- visualisation du type de données et du nombre de valeurs manquantes :¶
- Aucune valeur manquante n'est observée dans les deux jeux de données.
- L'attribut cible est un nombre entier et les autres attributs sont réels.
In [3]:
redWine.info()
In [4]:
whiteWine.info()
c- résumé descriptif des données :¶
- La varibale cible doit être une valeur compris entre [0 et 10]. Néanmoins, dans nos deux datasets elle est comprise entre [3 et 9] pour les vins rouges et [3 et 8] pour les blancs.
- La majorité des vins (rouge ou blanc) ont une qualité supérieure à la moyenne (Quality median = 6).
In [5]:
redWine.describe()
Out[5]:
In [6]:
whiteWine.describe()
Out[6]:
d - Proportion des données en fonction de la couleur du vin :¶
- Le nombre d'observations correspondant à du vin blanc est presque trois fois plus élevé que celui correspondant à du vin rouge.
In [7]:
fig1, ax1 = plt.subplots(facecolor=(1, 1, 1),figsize=(20,5))
ax1.pie([redWine.size,whiteWine.size], labels=('Red', 'White'), autopct='%1.1f%%',shadow=True, startangle=90)
ax1.axis('equal')
fig1.suptitle('Proportion des vins selon leur couleur', fontsize=16)
plt.show()
e - Répartition moyenne des notes en fonction de la couleur du vin :¶
- Les vins blancs ont tendance à avoir des notes plus élevées que celles des vins rouges.
In [8]:
whiteWine["type"]="White"
redWine["type"]="Red"
data = pd.concat([whiteWine,redWine],ignore_index=True)
data.insert(0,"count",1)
result = data[["quality","type","count"]].groupby(["quality","type"]).count()
result.reset_index(level=[0,1], inplace=True)
result=result.pivot("quality","type","count")
result["Red"] = result["Red"]/len(redWine)
result["White"] = result["White"]/len(whiteWine)
result.plot(kind='bar',figsize=(19.5,8),title= "Répartition moyenne des notes en fonction de la couleur du vin" )
plt.show()
whiteWine = whiteWine.drop(["type"],1)
redWine = redWine.drop(["type"],1)
2 - Répartition des données et détection des valeurs aberrantes :¶
Nous pouvons constater à travers les boîtes à moustache ci-dessous, qu'un grand nombre d'observations contiennent des valeurs aberrantes, qui peuvent faire référence à des erreurs dans les données ou à des cas spécifiques pouvant potentiellement biaiser notre modèle (elles peuvent également être dues au fait que l'ensemble de données soit petit et loin d'être exhaustive).
In [9]:
def showOutliers(white,red):
plt.figure(figsize=(20,20))
plt.suptitle('Boxplots de chaque feature mettant en évidence les valeurs aberrantes',fontsize=24)
for i in range(0,len(white.columns)):
plt.subplot(4,3,i+1)
plt.boxplot([white.iloc[:,i],red.iloc[:,i]])
plt.title(white.columns[i],fontsize=18)
showOutliers(whiteWine,redWine)
- Identifier le nombre d'observations contenant les valeurs aberrantes précédemment observées en utilisant l'intervalle interquartile (IQR) (z-score peut également être utilisée):
In [10]:
def getOutliersIndex(dataframe):
outliersIndex = set()
dataframe.reset_index(inplace=True,drop=True)
for i in range(0,len(dataframe.columns)):
p25 = np.percentile(dataframe.iloc[:,i],25)
p75 = np.percentile(dataframe.iloc[:,i],75)
iqr = p75 - p25
iqrXi = iqr*1.5
for j, val in enumerate(dataframe.iloc[:,i]):
if val < p25-iqrXi or val > p75 + iqrXi:
outliersIndex.add(j)
print("Nbr outliers : ",len(outliersIndex))
return outliersIndex
def dropOutliers(dataframe):
initialSize = len(dataframe)
cleanedData = dataframe.drop(getOutliersIndex(dataframe))
print(round((initialSize-len(cleanedData))*100/initialSize,1),"% of the lines will be deleted")
return cleanedData
- Nous constatons que la suppression des valeurs aberrantes entraînerait une perte considérable d'informations.
In [11]:
cleaningWhite = dropOutliers(whiteWine)
cleaningRed = dropOutliers(redWine)
- Nous constatons que la normalisation supprimera tous les vins dont la qualité est inférieure à 4 et supérieure à 7.
In [12]:
showOutliers(cleaningWhite,cleaningRed)
3- Sélection des attributs :¶
a- corrélation des données :¶
Les deux matrices de corrélation ci-dessous ne permettent pas de conclure à l'existence d'une très forte corrélation évidente entre :
- deux variables explicatives pour n'en sélectionner qu'une seule.
- une variable expliquée et une variable explicative qui démontre l'importance de cette dernière dans la prédiction.
Cependant, nous remarquons que la variable "alcohol" pourrait être la variable la plus importante pour la prédiction.
Nous pouvons observer à travers la matrice de corrélation ci-dessous (vins rouges):
- les variables ["fixed acidity", "citric acid", "density"],["free sulfur dioxide", "total sulfur dioxide"] sont positivement corrélées.
- les variables ["pH", "citric acid"], ["volatile acidity", "citric acid"], ["fixed acidity", "pH"] sont négativement corrélées.
In [13]:
corr = redWine.corr()
corr.style.background_gradient(cmap='coolwarm')
Out[13]:
In [14]:
corr = whiteWine.corr()
corr.style.background_gradient(cmap='coolwarm')
Out[14]:
b- Influence des attributs sur la qualité du vin :¶
- les attributs "citric acid", "sulphates", "alcool" ont une influence positive sur la qualité.
- les attributs "volatile acidity", "chlorides" et "pH" ont une influence négative sur la qualité.
- les attributs "residual sugar" et "dencity" ne semblent pas avoir une tendance apparente ou une grande variance, nous expérimenterons un modèle qui ne les prend pas en considération.
In [15]:
import plotly.graph_objects as go
dataMean=redWine.groupby("quality").mean()
dataMean.reset_index(level=0, inplace=True)
quality = dataMean.quality.to_list()
fig = go.Figure()
for i,colName in enumerate(dataMean.columns[1:]):
if i ==0:
fig.add_trace(go.Bar(y=quality,x=dataMean[colName].to_list(),orientation='h',name=colName))
else:
fig.add_trace(go.Bar(y=quality,x=dataMean[colName].to_list(),orientation='h',name=colName,visible='legendonly'))
fig.update_layout(barmode='group',title="Influence des attributs sur la qualité du vin", xaxis_title="Active legend attribut(default = fixed acidity)",yaxis_title="Quality Wine")
fig.show()
4- Prédiction de la qualité du vin :¶
In [16]:
def trainAndEvaluate(model,dataSet,withOutliers=False,TargetClass="quality"):
"""
Cette fonction permet de :
- withOutliers = True --> Supprimer les valeurs aberrantes (IQR).
- model = entraîner le modèle spécifié en paramètre.
- évaluer le modèle en utilisant la métrique de précision et la matrice de confusion.
"""
# séparer le jeu de données en variables explicatives et les variables expliquées.
if withOutliers:
X = dropOutliers(dataSet).drop(TargetClass, axis = 1)
y = dropOutliers(dataSet)[TargetClass]
else:
X = dataSet.drop(TargetClass, axis = 1)
y = dataSet[TargetClass]
# diviser le jeu de données en un jeu de formation et un jeu de test avec un échantillonnage stratifié pour garder la distribution initiale des classes
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = 1996,stratify=y)
# entrainer le modèle.
model.fit(X_train, y_train)
# prédiction du jeu de test
y_pred = model.predict(X_test)
# évaluation du modèle en utilisant la précision
print("Accuracy_score :",accuracy_score(y_pred,y_test))
# afficher la matrice de confusion
disp = plot_confusion_matrix(model, X_test, y_test,cmap=plt.cm.Blues)
disp.ax_.set_title("Confusion Matrix")
plt.show()
return model
A - Pour le vin blan :¶
- Vin blanc sans élimination des valeurs aberrantes :
Nous observons clairement à travers la matrice de corrélation ci-dessous que les classes ne sont pas correctement distribuées.
La solution est de supprimer les classes ayant un nombre insignifiant d’échantillons et cela soit avec un lissage par intervalle ou via la suppression des valeurs aberrantes.
In [17]:
# choix des hyperparamètres avec une recherche par grille.
calibrated_forest = CalibratedClassifierCV(base_estimator=RandomForestClassifier(n_estimators=500,random_state=1996))
param_grid = {'base_estimator__n_estimators':[400,500,600]}
rfModel = GridSearchCV(calibrated_forest, param_grid, cv=5)
trainAndEvaluate(rfModel,whiteWine,TargetClass="quality")
print("best_score of cross validation", rfModel.best_score_)
print("the best number of trees ", rfModel.best_params_)
- Vin blanc avec élimination des valeurs aberrantes (cette solution est brutale car nous n'avons pas une qtt importante de données) :
In [18]:
rfModelWithOut = RandomForestClassifier(n_estimators=400, random_state=1996)
trainAndEvaluate(rfModelWithOut,whiteWine,withOutliers=True,TargetClass="quality")
Out[18]:
- Vin blan lissage des classes :
In [19]:
def smoothingInterval(x):
if x > 6:
return 3
elif x < 6:
return 0
return 2
whiteWineSmoothed = whiteWine.copy()
whiteWineSmoothed["quality"] = whiteWine["quality"].map(smoothingInterval)
In [20]:
white_RF_Model_Smoothed = RandomForestClassifier(n_estimators=400, random_state=1996)
trainAndEvaluate(white_RF_Model_Smoothed,whiteWineSmoothed,withOutliers=False,TargetClass="quality")
Out[20]:
- Utiliser la forêt aléatoire pour la sélection des attributs :
In [21]:
varImportance = pd.DataFrame(white_RF_Model_Smoothed.feature_importances_.tolist(),index=whiteWineSmoothed.columns.to_list()[:-1],columns=["importance"])
varImportance.sort_values('importance')
Out[21]:
expérimenter la suppression de l'attribut le moins informatif "fixed acidity":
- la précision a légèrement diminué.
In [22]:
white_RF_Model_Smoothed_select = RandomForestClassifier(n_estimators=400, random_state=1996)
trainAndEvaluate(white_RF_Model_Smoothed_select,(whiteWineSmoothed.drop(["fixed acidity"], axis = 1)),TargetClass="quality")
Out[22]:
- Comme il est difficile de faire une sélection manuelle des attributs, il serait intéressant de procéder à une ACP.
In [23]:
X = whiteWineSmoothed.drop(['quality'], axis = 1)
y = whiteWineSmoothed['quality']
# Normalisation des données
sc_x=StandardScaler()
X = sc_x.fit_transform(X)
# Choix du nombre idéal de dimensions à conserver
pca=PCA()
X_pca = pca.fit_transform(X)
plt.figure(figsize=(10,8))
plt.plot(np.cumsum(pca.explained_variance_ratio_), 'ro-')
plt.grid()
- on constate que le nombre idéal d'attributs se situe entre 8 et 9, nous choisirons n_components = 8
In [24]:
# transformation des données avec l'acp
pca_new = PCA(n_components=8)
whitePCAData = (pd.DataFrame(pca_new.fit_transform(X))).join(pd.DataFrame(y,columns=["quality"]))
rf_PCA_Smooth_white = RandomForestClassifier(n_estimators=400, random_state=1996)
trainAndEvaluate(rf_PCA_Smooth_white,pd.DataFrame(whitePCAData),TargetClass="quality")
Out[24]:
b- Pour le vin rouge :¶
In [25]:
print("__________________________________Random Forest____________________________________________")
print("Choix des hyperparamètres (n_estimators)")
calibrated_forest = CalibratedClassifierCV(base_estimator=RandomForestClassifier(n_estimators=500,random_state=1996))
param_grid = {'base_estimator__n_estimators':[400,500,600]}
rfModel = GridSearchCV(calibrated_forest, param_grid, cv=5)
trainAndEvaluate(rfModel,redWine,TargetClass="quality")
print("best_score of cross validation", rfModel.best_score_)
print("the best number of trees ", rfModel.best_params_)
nbrtree = rfModel.best_params_["base_estimator__n_estimators"]
print("_______________________________________Remove Outliers_______________________________________")
rfModelWithOut = RandomForestClassifier(n_estimators=nbrtree, random_state=1996)
trainAndEvaluate(rfModelWithOut,redWine,withOutliers=True,TargetClass="quality")
print("_______________________________________Smoothing Classe_______________________________________")
redWineSmoothed = redWine.copy()
redWineSmoothed["quality"] = redWine["quality"].map(smoothingInterval)
red_RF_Model_Smoothed = RandomForestClassifier(n_estimators=nbrtree, random_state=1996)
trainAndEvaluate(red_RF_Model_Smoothed,redWineSmoothed,withOutliers=False,TargetClass="quality")
print("__________________________________________ACP________________________________________________")
X = redWineSmoothed.drop(['quality'], axis = 1)
y = redWineSmoothed['quality']
# Normalisation des données
sc_x=StandardScaler()
X = sc_x.fit_transform(X)
# Choix du nombre idéal de dimensions à conserver
pca=PCA()
X_pca = pca.fit_transform(X)
plt.figure(figsize=(10,8))
plt.plot(np.cumsum(pca.explained_variance_ratio_), 'ro-')
plt.grid()
# transformation des données avec l'acp
pca_new = PCA(n_components=8)
redPCAData = (pd.DataFrame(pca_new.fit_transform(X))).join(pd.DataFrame(y,columns=["quality"]))
rf_PCA_Smooth_red = RandomForestClassifier(n_estimators=nbrtree, random_state=1996)
trainAndEvaluate(rf_PCA_Smooth_red,pd.DataFrame(redPCAData),TargetClass="quality")
Out[25]:
Les deux modèles pouvant être intégrés à la production sont :¶
J'ai choisi d'utiliser les deux modèles ci-dessous de manière à obtenir la plus grande précision.
Et ce, sans supprimer les valeurs aberrantes et sans effectuer une sélection d'attributs.
Car, malgré la possibile d'avoir une grande précision en réalisant cette série de prétriatements, nos modèles peuvent être sujets à un sur-apprentissage (faible en généralisation à cause de la taille infime de nos deux ensembles de données).
I- Modèle pour le vin blanc :¶
- Accuracy_score : 0.752040
In [26]:
dump(white_RF_Model_Smoothed,"model/WhiteWineModel.pkl")
Out[26]:
II- Modèle pour le vin rouge :¶
- Accuracy_score : 0.771875
In [27]:
dump(red_RF_Model_Smoothed,"model/RedWineModel.pkl")
Out[27]:
Perspectives :¶
Il est également intéressant de tester d'autres modèles d'apprentissage automatique basés sur des réseaux de neurones qui peuvent potentiellement avoir une meilleure précision.